תוכלו לעיין במאגר של Gemma Cookbook לקבלת דוגמאות ליצירה ולכוונון! מידע נוסף

דף זה תורגם על ידי Cloud Translation API.

יצירת עוזר AI לאימייל עסקי באמצעות Gemma

הטיפול בפניות של לקוחות, כולל אימיילים, הוא חלק חיוני עסקים רבים, אבל מהר מאוד הוא עלול להיות מוצף. עם קצת מאמץ, מודלים של בינה מלאכותית (AI) כמו Gemma יכולים לעזור לכם לעשות את זה בקלות.

כל עסק מטפל בבקשות, כמו אימיילים, בצורה שונה, ולכן חשוב שתוכלו להתאים טכנולוגיות כמו AI גנרטיבי לצרכים של העסק. הפרויקט הזה עוסק בבעיה הספציפית של חילוץ פרטי ההזמנות מהאימיילים שנשלחים למאפייה לנתונים מובְנים, כדי שאפשר יהיה להוסיף אותם במהירות למערכת לטיפול בהזמנות. בעזרת 10 עד 20 דוגמאות של בקשות תמיכה והפלט הרצוי, תוכלו להתאים אישית מודל של Gemma כדי לעבד אימיילים מהלקוחות, לעזור לכם להשיב במהירות ולשלב את המודל במערכות העסקיות הקיימות שלכם. הפרויקט הזה נבנה בתור תבנית של אפליקציית AI שאפשר להרחיב ולהתאים כדי להפיק ערך מהמודלים של Gemma לעסק שלכם.

בסרטון Business Email AI Assistant Build with Google AI מוסבר על הפרויקט ועל האופן שבו אפשר להרחיב אותו, כולל תובנות מהאנשים שפיתחו אותו. אפשר גם לעיין בקוד של הפרויקט הזה במאגר הקוד של Gemma Cookbook. אם לא, תוכלו להתחיל להרחיב את הפרויקט באמצעות הוראות להתאמה אישית.

סקירה כללית

המדריך הזה מסביר איך להגדיר, להפעיל ולהרחיב עסק אפליקציית העוזר הדיגיטלי באימייל שפותחה באמצעות Gemma , Python ו-Flask. בפרויקט יש ממשק משתמש בסיסי לאינטרנט שאפשר לשנות בהתאם לצרכים שלכם. מיועדת לחלץ למבנה נתונים מהאימיילים של הלקוחות למאפייה פיקטיבית. אפשר להשתמש בתבנית הזאת לכל עסק שמשתמשת בקלט טקסט ובפלט טקסט.

צילום מסך של ממשק המשתמש של אפליקציית האינטרנט

איור 1. ממשק משתמש בפרויקט לעיבוד פניות באימייל לגבי מאפייה

דרישות החומרה

אפשר להריץ את תהליך הכוונון הזה במחשב עם יחידת עיבוד גרפי (GPU) או יחידת עיבוד של Tensor (TPU), ומספיק זיכרון GPU או TPU כדי להחזיק את המודל הקיים, וגם נתוני הכוונון. כדי להריץ את תצורת הכוונון צריך כ-16GB של זיכרון GPU, בערך אותה כמות זיכרון RAM ונפח אחסון של 50GB לפחות.

אתם יכולים להריץ את החלק של התאמת המודל ב-Gemma במדריך הזה באמצעות סביבת Colab עם סביבת זמן ריצה של GPU מסוג T4. אם אתם מפתחים את הפרויקט הזה במכונה וירטואלית ב-Google Cloud, צריך להגדיר את המכונה בהתאם לדרישות הבאות:

חומרת GPU: נדרש NVIDIA T4 כדי להריץ את הפרויקט הזה (NVIDIA). מומלץ L4 ומעלה)
מערכת הפעלה: בוחרים באפשרות למידת עומק ב-Linux, ובפרט מכונה וירטואלית ללמידת עומק עם CUDA 12.3 M124 עם מנהלי תוכנה מותקנים מראש של GPU.
גודל דיסק האתחול: צריך להקצות לפחות 50GB של נפח דיסק לנתונים, למודלים ולתוכנות התמיכה.

הגדרת הפרויקט

ההוראות הבאות ינחו אותך איך להכין את הפרויקט לפיתוח ובדיקות. שלבי ההגדרה הכלליים כוללים התקנת תוכנה שנדרשת מראש, לשכפל את הפרויקט ממאגר הקודים, להגדיר כמה סביבה במשתנים שונים, התקנת ספריות Python ובדיקת אפליקציית האינטרנט.

התקנה והגדרה

בפרויקט הזה נעשה שימוש ב-Python 3 ובסביבות וירטואליות (venv) כדי לנהל את החבילות ולהריץ את האפליקציה. הוראות ההתקנה הבאות מיועדות למכונה מארחת של Linux.

כדי להתקין את התוכנה הנדרשת:

מתקינים את Python 3 ואת חבילת הסביבה הווירטואלית venv ל-Python:
```
sudo apt update
sudo apt install git pip python3-venv
```

שכפול הפרויקט

מורידים את קוד הפרויקט למחשב הפיתוח. צריך של git לבקרת מקור כדי לאחזר את את קוד המקור של הפרויקט.

כדי להוריד את קוד הפרויקט:

משכפלים את מאגר ה-Git באמצעות הפקודה הבאה:
```
git clone https://github.com/google-gemini/gemma-cookbook.git
```
אפשר גם להגדיר את מאגר ה-Git המקומי כך שישתמש ב-sparse checkout, כך שיישארו רק הקבצים של הפרויקט:
```
cd gemma-cookbook/
git sparse-checkout set Demos/business-email-assistant/
git sparse-checkout init --cone
```

התקנת ספריות Python

מתקינים את ספריות Python עם סביבת Python הווירטואלית venv מופעלת כדי לנהל את החבילות ואת יחסי התלות של Python. חשוב להקפיד להפעיל את בסביבה הווירטואלית של Python לפני שמתקינים ספריות Python באמצעות pip של מנהל ההתקנה. מידע נוסף על שימוש בסביבות וירטואליות של Python זמין במסמכי העזרה של Python venv.

כדי להתקין את ספריות Python:

בחלון הטרמינל, עוברים לספרייה business-email-assistant:
```
cd Demos/business-email-assistant/
```
מגדירים ומפעילים את הסביבה הווירטואלית של Python (venv) לפרויקט הזה:
```
python3 -m venv venv
source venv/bin/activate
```
מתקינים את ספריות Python הנדרשות לפרויקט הזה באמצעות סקריפט setup_python:
```
./setup_python.sh
```

הגדרה של משתני סביבה

כדי להריץ את הפרויקט הזה נדרשים כמה משתני סביבה סביבתיים כולל שם משתמש של Kaggle ואסימון Kaggle API. כדי להוריד אותם, צריך חשבון Kaggle ולבקש גישה למודלים של Gemma. בפרויקט הזה, מוסיפים את שם המשתמש ב-Kaggle ואת הטוקן של Kaggle API לשני קבצים מסוג .env, שאותם קוראים אפליקציית האינטרנט ותוכנית התכוונון, בהתאמה.

כדי להגדיר את משתני הסביבה:

פועלים לפי ההוראות כדי לקבל את שם המשתמש ב-Kaggle ואת מפתח האסימון במסמכי התיעוד של Kaggle.
כדי לקבל גישה למודל Gemma, פועלים לפי ההוראות לקבלת גישה ל-Gemma בדף הגדרת Gemma.
יוצרים קובצי משתני סביבה לפרויקט. לשם כך, יוצרים קובץ טקסט מסוג .env בכל המיקומים הבאים בעותק המשובך של הפרויקט:
```
email-processing-webapp/.env
model-tuning/.env
```
אחרי שיוצרים את קובצי הטקסט .env, מוסיפים את ההגדרות הבאות לשני הקובצים:
```
KAGGLE_USERNAME=<YOUR_KAGGLE_USERNAME_HERE>
KAGGLE_KEY=<YOUR_KAGGLE_KEY_HERE>
```

הרצה ובדיקה של האפליקציה

לאחר סיום ההתקנה והתצורה של הפרויקט, מפעילים את אפליקציית האינטרנט כדי לוודא שהגדרתם אותה בצורה נכונה. כדאי לעשות זאת כבדיקה בסיסית לפני שעורכים את הפרויקט לשימוש עצמי.

כדי להריץ ולבדוק את הפרויקט:

בחלון הטרמינל, עוברים לספרייה email-processing-webapp:
```
cd business-email-assistant/email-processing-webapp/
```
מריצים את האפליקציה באמצעות הסקריפט run_app:
```
./run_app.sh
```
אחרי שמפעילים את אפליקציית האינטרנט, קוד התוכנית מציג כתובת URL שבה אפשר לעיין ולבדוק. בדרך כלל הכתובת הזו היא:
```
http://127.0.0.1:5000/
```
בממשק האינטרנט, לוחצים על הלחצן Get data מתחת לשדה הקלט הראשון כדי ליצור תשובה מהמודל.

התגובה הראשונה מהמודל אחרי הפעלת האפליקציה נמשכת זמן רב יותר, כי הוא צריך להשלים את שלבי האיפוס ברצף ההפעלה הראשון. בקשות ופניות נוספות שייווצרו באפליקציית אינטרנט שכבר פועלת יסתיימו בזמן קצר יותר.

הרחבת הבקשה

אחרי שהאפליקציה פועלת, אפשר להרחיב אותה על ידי שינוי ממשק המשתמש והלוגיקה העסקית כדי שתתאים למשימות שרלוונטיות לכם או לעסק שלכם. אפשר גם לשנות את ההתנהגות של מודל Gemma באמצעות את הקוד של האפליקציה באמצעות שינוי הרכיבים של ההנחיה שהאפליקציה שולחת של בינה מלאכותית גנרטיבית.

האפליקציה מספקת הוראות למודל יחד עם נתוני הקלט מהמשתמש, כדי להציג למודל הנחיה מלאה. אפשר לשנות את ההוראות האלה כדי לשנות את התנהגות המודל, למשל לציין את שמות הפרמטרים ואת המבנה של ה-JSON שייווצר. דרך פשוטה יותר לשנות את ההתנהלות של הוא לספק הוראות או הנחיות נוספות למודל, למשל, לציין שהתשובות שנוצרות לא יכולות לכלול עיצוב Markdown.

כדי לשנות את ההוראות לגבי ההנחיה:

בפרויקט הפיתוח, פותחים את קובץ קוד business-email-assistant/email-processing-webapp/app.py.

בקוד app.py, מוסיפים הוראות נוספות לפונקציה get_prompt()::

def get_prompt():
  return """
    Extract the relevant details of this request and return them in
    JSON code, with no additional markdown formatting:\n"""

בדוגמה הזו מתווסף הביטוי 'ללא עיצוב נוסף לסימון למטה' ל הוראות להתאמה אישית.

מתן הוראה להנחיות נוספות יכול להשפיע באופן משמעותי על הפלט, וההטמעה שלהן הרבה יותר נמוכה באופן משמעותי. כדאי לך לנסות את זה כדי לבדוק אם אפשר לקבל מהמודל את ההתנהגות הרצויה. עם זאת, כדי לשנות את ההתנהגות של מודל Gemma באמצעות הנחיות לשינוי התנהגות של מודל Gemma, מגבלות בפועל. באופן ספציפי, מגבלת האסימונים הכוללת של הקלט של המודל, שהיא 8,192 אסימונים ב-Gemma 2, מחייבת איזון בין הוראות מפורטות להנחיה לבין הגודל של הנתונים החדשים שאתם מספקים, כדי לא לחרוג מהמגבלה הזו.

כוונון המודל

ביצוע כוונון מדויק של מודל Gemma היא הדרך המומלצת לקבל תשובות מהימנות יותר במשימות ספציפיות. באופן ספציפי, אם אתם רוצים שהמודל ייצור קובץ JSON עם מבנה ספציפי, כולל פרמטרים עם שמות ספציפיים, כדאי לשקול לכוונן את המודל להתנהגות הזו. בהתאם למשימה שאתם רוצים שהמודל ישלים, אפשר לבצע עריכות בסיסיות פונקציונליות עם 10 עד 20 דוגמאות. הקטע הזה במדריך שמסבירה איך להגדיר ולהפעיל כוונון עדין של מודל Gemma לביצוע משימה ספציפית.

ההוראות הבאות מסבירות איך לבצע את פעולת הכוונון אבל אפשר לבצע את פעולת הכוונון גם באמצעות שמשויכים לכל אחד Colab notebook (הוספת פתקים ב-Colab) לפרויקט הזה.

דרישות חומרה

דרישות המחשוב לכוונון עדין זהות לדרישות המחשוב דרישות החומרה לשאר הפרויקט. אפשר להריץ את פעולת ההתאמה בסביבת Colab עם סביבת זמן ריצה של GPU T4 אם מגבילים את האסימונים של הקלט ל-256 ואת גודל האצווה ל-1.

הכנת הנתונים

לפני שמתחילים לכוונן מודל Gemma, צריך להכין נתונים לכוונון. מתי אתם מכווננים מודל למשימה ספציפית, צריך אוסף של בקשות דוגמאות לתשובות. הדוגמאות האלה צריכות להציג את טקסט הבקשה, ללא הוראות, ואת טקסט התשובה הצפוי. בשלב הראשון, צריך להכין מערך נתונים עם כ-10 דוגמאות. הדוגמאות האלה אמורות לייצג מגוון רחב של בקשות ואת התשובות האידיאליות אליהן. ודאו שהבקשות לא חוזרות על עצמן, וזה עלול לגרום לתשובות של המודלים שחוזרות על עצמן ולא ישתנו בצורה המתאימה לשינויים בבקשות. אם אתם לכוונן את המודל כדי ליצור פורמט של נתונים מובְנים, לוודא שכל בדיוק לפי הפורמט הרצוי של פלט הנתונים. בטבלה הבאה מוצגות כמה רשומות לדוגמה מתוך מערך הנתונים של דוגמת הקוד הזו:

בקשה	תשובה
שלום Indian Bakery Central,\nהאם יש לך 10 פנדות ושלושים בונדי לאדו? האם אתם מוכרים גם ציפוי וניל עוגות בטעמים שוקולד. אני מנסה לקנות בגודל 6 אינץ'	{ "type": "inquiry", "items": [ { "name": "pendas", "quantity": 10 }, { "name": "bundi ladoos", "quantity": 30 }, { "name": "cake", "filling": null, "frosting": "vanilla", "flavor": "chocolate", "size": "6 in" } ] }
ראיתי את העסק שלך במפות Google. האם מוכרים לך ג'לאבי וגולאב Jamun?	{ "type": "inquiry", "items": [ { "name": "jellabi", "quantity": null }, { "name": "gulab jamun", "quantity": null } ] }

טבלה 1. רישום חלקי של מערך הנתונים של הכוונון של נתוני האימייל של המאפייה שחולץ.

פורמט הנתונים והטעינה שלהם

אתם יכולים לאחסן את נתוני ההתאמה האישית בכל פורמט שנוח לכם, כולל רשומות במסדי נתונים, קובצי JSON, קובצי CSV או קובצי טקסט רגילים, כל עוד יש לכם אפשרות לאחזר את הרשומות באמצעות קוד Python. בפרויקט הזה המערכת מקריאה קובצי JSON מספריית data למערך אובייקטים במילון. בתוכנית לדוגמה הזאת של סיבוב, מערך הנתונים של הכוונון נטען מודול model-tuning/main.py באמצעות הפונקציה prepare_tuning_dataset():

def prepare_tuning_dataset():
    # collect data from JSON files
    prompt_data = read_json_files_to_dicts("./data")
    ...

כפי שצוין קודם, אפשר לאחסן את מערך הנתונים בפורמט נוח, כל עוד אפשר לאחזר את הבקשות עם התשובות המשויכות ולקבץ אותן למחרוזת טקסט שתשמש כרשומת כוונון.

הרכבה של רשומות כוונון

בתהליך הכוונון בפועל, התוכנה מרכיבה כל בקשה ותגובה. למחרוזת אחת, עם ההוראות הפרומפט והתוכן של תשובה. לאחר מכן תוכנית הכוונון הופכת את המחרוזת לאסימונים כדי שהיא תהיה צריכה לשימוש על ידי מודל טרנספורמר. אפשר לראות את הקוד להרכבת רשומת כוונון הפונקציה prepare_tuning_dataset() של מודול model-tuning/main.py מתבצעת באופן הבא:

def prepare_tuning_dataset():
    ...
    # prepare data for tuning
    tuning_dataset = []
    template = "{instruction}\n{response}"

    for prompt in prompt_data:
        tuning_dataset.append(template.format(instruction=prompt["prompt"],
                                              response=prompt["response"]))

    return tuning_dataset

הפונקציה הזו לוקחת את הנתונים כקלט ומעצבת אותם על ידי הוספת מעבר שורה בין ההוראה לתגובה.

יצירת משקולות למודל

לאחר שנתוני הכוונון ייטענו ויתקנו, אפשר להפעיל בתוכנית. בתהליך הכוונון של האפליקציה לדוגמה הזו נעשה שימוש ב-Keras NLP לספרייה כדי לכוונן את המודל באמצעות התאמת דירוג נמוך, או שיטת LoRA, כדי ליצור משקולות מודל חדשות. בהשוואה לכוונון מדויק מלא, השימוש ב-LoRA יעיל יותר בזיכרון, מכיוון שהוא מתאר את השינויים את משקולות המודל. לאחר מכן תוכלו להוסיף את המשקלים המשוערים האלה על משקלי המודל הקיימים כדי לשנות את התנהגות המודל.

כדי לבצע את הרצת הכוונון ולחשב משקולות חדשות:

בחלון מסוף, עוברים לספרייה model-tuning/.
```
cd business-email-assistant/model-tuning/
```
מריצים את תהליך ההתאמה באמצעות הסקריפט tune_model:
```
./tune_model.sh
```

תהליך הכוונון נמשך מספר דקות, בהתאם למחשוב הזמין במשאבי אנוש. בסיום התהליך, תוכנית התאמת ההגדרות כותבת קובצי משקל חדשים של *.h5 בספרייה model-tuning/weights בפורמט הבא:

gemma2-2b_inquiry_tuned_4_epoch##.lora.h5

פתרון בעיות

אם התכונה לא מותאמת בהצלחה, יכולות להיות לכך שתי סיבות:

אין מספיק זיכרון או משאבים נגמרו: השגיאות האלה מתרחשות כאשר תהליך הכוונון מבקש זיכרון שחורגים מזיכרון ה-GPU או מהמעבד (CPU) הזמינים זיכרון. חשוב לוודא שאתם לא מריצים את אפליקציית האינטרנט בזמן שתהליך ההתאמה פועל. אם מבצעים התאמה במכשיר עם זיכרון GPU בנפח 16GB, צריך לוודא שהערך של token_limit מוגדר ל-256 והערך של batch_size מוגדר ל-1.
מנהלי GPU שלא מותקנים או לא תואמים ל-JAX: תהליך ההמרה מחייב התקנה של מנהלי חומרה במכשיר המחשוב שתואמים לגרסה של ספריות JAX. פרטים נוספים זמינים במאמר התקנת JAX התיעוד.

פריסת מודל מותאם

תהליך ההתאמה יוצר מספר משקלים על סמך נתוני ההתאמה ומספר ה-epochs הכולל שהוגדר באפליקציית ההתאמה. כברירת מחדל, תוכנית הכוונון יוצרת 3 קובצי משקל של מודל, אחד לכל תקופת כוונון. כל אחד תקופה של כוונון רציף יוצרת משקולות שמחזירות בצורה מדויקת יותר של נתוני הכוונון. ניתן לראות את שיעורי הדיוק של כל תקופה של זמן מערכת הפלט הטרמינל של תהליך הכוונון, באופן הבא:

...
8/8 ━━━━━━━━━━━━━━━━━━━━ 121s 195ms/step - loss: 0.5432 - sparse_categorical_accuracy: 0.5982
Epoch 2/3
8/8 ━━━━━━━━━━━━━━━━━━━━ 2s 194ms/step - loss: 0.3320 - sparse_categorical_accuracy: 0.6966
Epoch 3/3
8/8 ━━━━━━━━━━━━━━━━━━━━ 2s 192ms/step - loss: 0.2135 - sparse_categorical_accuracy: 0.7848

חשוב שהרמת הדיוק תהיה גבוהה יחסית, בסביבות 0.80, אבל לא גבוהה מדי או קרובה מאוד ל-1.00, כי זה אומר שהמשקלים קרובים להתאמה יתר לנתוני ההתאמה. במקרה כזה, לא יניב ביצועים טובים בבקשות שונות באופן משמעותי את הדוגמאות לכוונון. כברירת מחדל, סקריפט הפריסה בוחר את התקופה 3 משקולות, שבדרך כלל יש להן שיעור דיוק של כ-0.80.

כדי לפרוס את המשקלים שנוצרו באפליקציית האינטרנט:

בחלון מסוף, עוברים לספרייה model-tuning:
```
cd business-email-assistant/model-tuning/
```
מריצים את תהליך הכוונון באמצעות הסקריפט deploy_weights:
```
./deploy_weights.sh
```

לאחר הרצת הסקריפט, אתם אמורים לראות קובץ *.h5 חדש בקטע הספרייה email-processing-webapp/weights/.

בדיקת המודל החדש

אחרי שפרסתם את המשקולות החדשות באפליקציה, הגיע הזמן לנסות את המודל החדש שעבר כוונון. אפשר לעשות זאת על ידי הרצה מחדש של אפליקציית האינטרנט יצירת תגובה.

כדי להריץ ולבדוק את הפרויקט:

בחלון הטרמינל, עוברים לספרייה email-processing-webapp:
```
cd business-email-assistant/email-processing-webapp/
```
מריצים את האפליקציה באמצעות הסקריפט run_app:
```
./run_app.sh
```
אחרי שמפעילים את אפליקציית האינטרנט, מוצגת כתובת URL בקוד התוכנית שבה אפשר לעיין ולבדוק. בדרך כלל הכתובת הזו היא:
```
http://127.0.0.1:5000/
```
בממשק האינטרנט, לוחצים על הלחצן Get data מתחת לשדה הקלט הראשון כדי ליצור תשובה מהמודל.

עכשיו מכווננת ופרסתם מודל Gemma באפליקציה! כדאי להתנסות באפליקציה ולנסות לקבוע את המגבלות של יכולת היצירה של המודל המכוונן עבור המשימה שלכם. אם תמצאו תרחישים שבהם המודל לא מבצע כדאי להוסיף חלק מהבקשות האלה לרשימת הנתונים לדוגמה של הכוונון באמצעות הוספת הבקשה ומתן תשובה אידיאלית. לאחר מכן יש להריץ מחדש את הכוונון לפרוס מחדש את המשקולות החדשות ולבדוק את הפלט.

מקורות מידע נוספים

מידע נוסף על הפרויקט הזה זמין במאמר מאגר הקודים של Gemma Cookbook אם אתם צריכים עזרה בפיתוח האפליקציה או רוצים לשתף פעולה עם מפתחים אחרים, תוכלו להיכנס לשרת Google Developers Community Discord. בפרויקטים נוספים של Build with Google AI, אפשר לעיין פלייליסט של סרטונים.